\section{Desarrollo}
\noindent Para la resolución de los tres ejercicios implementamos los métodos Newton y Bisección. Realizamos un método de Bisección para la función con rozamiento y otro para el caso sin rozamiento, estas dos implementaciones se diferencian sólo en la función que utilizan, lo mismo ocurre con Newton. También utilizamos estos métodos para calcular la altura máxima en el ejercicio 2.
\\
Analicemos bisección: lo primero que hacemos es ver si se cumple la hipotesís $f(a)*(b) < 0$ dado que ya sabemos que las funciones son continuas por ser polinomios:
\begin{verbatim}
if (f(a)*f(b) >= 0)
{
    cout << "FAIL" << endl;
    return 1;
}

\end{verbatim}

Entonces si no se puede usar bisección devolvemos un mensaje de error y terminamos. Ahora veamos la ejecución de bisección:

\begin{verbatim}
while(|b - a| > error)
{
  m = (a + b)/ 2);
  if (f(a) * f(m) < 0)
  {
    b = m;
  }
  if (f(m) * f(b) < 0)
  {
    a = m;
  }
}
\end{verbatim}

\noindent El algoritmo lo repetimos mientras el intervalo tenga una longitud mayor al error que queremos, de esta manera nos aseguramos la precisión que deseamos. Luego comparamos $f(m)$, donde $m$ es el valor medio del intervalo, con $f(a)$ y $f(b)$ para ver cuál será el nuevo intervalo.
\\ 
Para Newton además de $f$ utilizamos la derivada de $f$. En el caso en que $f$ es la función de posición ya sabemos que su derivada es la función de velocidad (ver \textit{Enunciado}), pero para cuando $f$ es la función velocidad (en el ejercicio 2) tuvimos que calcular la derivada y nos quedo:
\begin{center}
 $f'(t)=(v_0 + \frac{g}{\alpha})*(-\alpha e^{-\alpha t})$
\end{center}
Veamos ahora Newton:
\begin{verbatim}
do
{
  xi = xf;
  xf = xi - f(h, vi, A, xi, g, e)/f'(vi, A, xi, g, e);
  it++;
}
while(|xf - xi| > error || it < limiteIt));

return xf;
\end{verbatim}
Este código implementa la sucesión $x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}$. La función recibe un $x_i$ inicial que irá reemplazando por $\frac{f(x_i)}{f'(x_i)}$. Este paso lo realizará hasta que la diferencia entre dos términos de la sucesión sea menor o igual al error deseado o que el algoritmo alcance un límite de iteraciones ($limiteIt$) para el caso en que no converja, ya que si no converge puede quedarse ciclando infinitamente. Finalmente, devuelve el último elemento de la sucesión que será aquel que se acerque más a la raíz. Es claro que no sabemos que tan cerca de la raíz estamos, si la función presentase una asintota muy marcada cerca del cero nuestro algoritmo podría terminar lejos del valor que hace exactamente 0 a la función, pero estos son casos más específicos. En conclusión, sabemos que ningún criterio de parada es seguro, pero este es el que utilizamos en nuestras pruebas pues es el que más confianza nos generó desde la parte teórica.
\\
Estos son los dos métodos con los que trabajamos, cada uno lo usamos para calcular los ceros de tres funciones: $posicionConRozamiento(t)$, $posicionSinRozamiento(t)$ y $velocidad(t)$. Para Newton necesitamos las derivadas de cada función, que respectivamente son: $velocidadConRozamiento(t)$, $velocidadSinRozamiento(t)$ y $velocidad'(t) = -(v_0*\alpha + g)*e^{-\alpha*t}$ (para las otras funciones ver \textit{Enunciado}).

\subsection{Ejercicio 1}

Para este ejercicio comparamos los métodos de Bisección y Newton en los aspectos de precisión y tiempo de ejecución. Realizamos varias experiencias fijando los valores de altura, velocidad inicial y coeficiente de rozamiento para ambos métodos y variaciones de los parámetros de: error e iteraciones, que son los que afectan el rendimiento del algoritmo, dado que los otros parámetros son constantes de las funciones a las que les estamos aproximando la raíz y no influyen en la cantidad de iteraciones o en la precisión del valor que devuelven nuestros métodos.
\\
La primera experiencia que hicimos fue para Newton, probar varios $x_0$ iniciales, donde para algunos la sucesión no convergía. Comparamos entonces, para los que sí convergían, las iteraciones que le tomaba al algoritmo conseguir un ``buen'' resultado. Para darnos una idea de un buen resultado tomamos aquel que nos dió el algoritmo de Bisección (ver \textit{Resultados})
\\
Una vez obtenido un $x_0$ apropiado para Newton comparamos con Bisección las iteraciones que les tomaban conseguir un cero aproximado con cierto error, es decir que fuimos variando los errores y viendo la cantidad de iteraciones que el algoritmo necesitaba realizar para obtener una solución que satisfaciera ese error. Hicimos también la experiencia inversa, donde variando las iteraciones vemos que tan bueno es el cero que nos devuelve el algoritmo. 
\\
También realizamos estas experiencias para la combinación de Newton y Bisección. Para ello lo que hicimos fue primero calcular un $x_0$ con Bisección (para el que pedimos un error bastante grande, realizando pocas iteraciones) y luego usar Newton, este caso nos sirvió para ya tener una idea del $x_0$ que se puede utilizar sin tener que realizar experiencias para buscarlo.

\subsection{Ejercicio 2}

Para resolver el ejercicio dos, donde se pide la altura máxima después del primer impacto y el momento del segundo impacto utilizamos los mismos métodos pero sobre diferentes funciones. Lo que hicimos fue, una vez calculado el momento del primer impacto, modificamos la velocidad inicial del sistema con la fórmula del impacto (ver fórmula 5 en \textit{Enunciado}) y la altura inicial que en este caso será 0, esto nos da la misma función posición pero con distintas constantes. De esta manera calculamos el segundo impacto de igual manera que calculamos el primero, salvo que esta vez la función es distinta, o al menos cambian sus constantes.
\\
En cuanto a la altura máxima alcanzada, sabemos que está se llega a ella cuando la velocidad llega a 0 (el objeto que rebotó en el suelo sube desacelerando hasta alcanzar la velocidad 0 y comienza a descender). Teniendo esto en cuenta, buscamos con los mismos métodos (Bisección y Newton) el cero de la función de velocidad. De esta manera obtuvimos el momento $t$ en que se alcanza la altura máxima y utilizando la función de posición para este $t$ conseguimos la altura máxima luego del primer impacto.
\\
Como los análisis de los algoritmos y su rendimiento los obtuvimos en el primer ejercicio, para este caso nos centramos en como funcionaban nuestros métodos para distintos casos reales. Es decir las experiencias realizadas se basaron en variar la altura y la velocidad que en un principio no deberían afectar directamente a los métodos aunque es claro que influyen, dado que distintas constantes en la función me pueden dar valores más complicados de interpretar en la máquina, como por ejemplo números irracionales.

\subsection{Ejercicio 3}

Para este último ejercicio calculamos la energía mecánica en el momento 0, es decir en el instante del lanzamiento y luego la calculamos en el momento del segundo impacto (que nos devolvió el metodo, es decir, es un valor aproximado). Una vez obtenidos ambos valores, realizamos la resta y obtuvimos la diferencia entre la energía mecánica entre el lanzamiento y el segundo rebote. De esta manera podemos analizar la variación, como pide el enunciado. 
\\
En este ejercicio, las experiencias consistieron en ir variando los parámetros de entrada que toma el programa ($\alpha$, $f_r$ y la precisión númerica).


